#include "../include/head.h"

// #define WHEELMAX 3     // 修改为3个轮片用于测试
// #define MAX_SET_SIZE 1024  // 定义集合最大大小
// #define MAX_ELEMENTS 4096  // 定义最大元素数

// typedef struct SET{
//     int idx;
//     int arr[MAX_SET_SIZE];
// }SET_t;

// typedef struct TimeWheel{
//     SET_t* wheel[WHEELMAX];
//     int isalive[MAX_ELEMENTS];
//     int count;
// }TimeWheel_t;

int set_delete(SET_t* set,int netfd)
{
    int i=0;
    while(netfd!=set->arr[i]&&i<set->idx){
        i++;
    }
    if(i==set->idx) return 0;
    for(;i<set->idx;i++){
        set->arr[i]=set->arr[i+1];
    }
    --set->idx;
    return 1;
}

int set_insert(SET_t* set,int x){
    for(int i=0;i<set->idx;i++){
        if(set->arr[i]==x){
            printf("%d已存在\n",x);
            return set->idx;
        }
    }
    set->arr[set->idx]=x;
    ++set->idx;
    return set->idx;
}

void print_set(SET_t* set) {
    if (!set) {
        printf(" NULL set\n");
        return;
    }
    for (int i = 0; i < set->idx; i++) {
        printf("%d", set->arr[i]);
        if (i < set->idx - 1) printf(", ");
    }
    printf("\n");
}

TimeWheel_t* TimeWheel_create(){
    TimeWheel_t* timewheel = (TimeWheel_t*)calloc(1, sizeof(TimeWheel_t));
    if (!timewheel) return NULL;  // 检查内存分配
    
    // 初始化时间轮槽位
    for (int i = 0; i < WHEELMAX; i++) {
        timewheel->wheel[i] = (SET_t*)calloc(1, sizeof(SET_t));
    }
    memset(timewheel->isalive,-1,sizeof(timewheel->isalive));
    timewheel->count = 0;
    return timewheel;
}

int TimeWheel_upwheel(TimeWheel_t* timewheel, int index, int value) {
    if (!timewheel || index < 0 || index >= WHEELMAX) {
        return -1;
    }

    SET_t* oldset = timewheel->wheel[index];
    SET_t* newset = (SET_t*)calloc(1, sizeof(SET_t));

    // 将不需要删除的元素复制到新集合
    for (int i = 0; i < oldset->idx; i++) {
        if (oldset->arr[i] != value) {
            newset->arr[newset->idx] = oldset->arr[i];
            ++newset->idx;
        }
    }
    // 更新时间轮
    timewheel->wheel[index] = newset;
    free(oldset);
    
    return 0;
}


SET_t* TimeWheel_insert(TimeWheel_t* timewheel,SET_t* set){
    
    // 检查set中的每个元素 将他插入isalive[]
    for (int i = 0; i < set->idx; i++) {
        int n = set->arr[i];
        // 如果元素已经存在
        if (timewheel->isalive[n] != -1) {
            TimeWheel_upwheel(timewheel, timewheel->isalive[n], n);
        }
        timewheel->isalive[n]=timewheel->count;
    }

    int index = timewheel->count;
    SET_t* resset=timewheel->wheel[index];
    //将timewheel->isalive[]中的值设为-1;
    for(int i=0;i<resset->idx;i++){
        int x=resset->arr[i];
        timewheel->isalive[x]=-1;
    }
    
    timewheel->wheel[index] = set;
    timewheel->count = (index + 1) % WHEELMAX;
    
    return resset;
}

int TimeWheel_deletefd(TimeWheel_t* timewheel,int netfd){
    if(timewheel->isalive[netfd]!=-1){
        int indx=timewheel->isalive[netfd];
        set_delete(timewheel->wheel[indx],netfd);
        timewheel->isalive[netfd]=-1;  //设为-1;
    }
    return 1;   
}

void TimeWheel_destroy(TimeWheel_t* timewheel) {
    if (!timewheel) return;
    
    // 释放所有槽位的内存
    for (int i = 0; i < WHEELMAX; i++) {
        if (timewheel->wheel[i]) {
            free(timewheel->wheel[i]);
        }
    }  
    // 释放时间轮结构体
    free(timewheel);
}

// 打印时间轮当前状态
void print_wheel_state(TimeWheel_t* tw) {
    printf("\n==== 时间轮状态 (当前位置: %d) ====\n", tw->count);
    for(int i = 0; i < WHEELMAX; i++) {
        printf("轮片[%d]: ", i);
        if(tw->wheel[i]) {
            for(int j = 0; j < tw->wheel[i]->idx; j++) {
                printf("%d ", tw->wheel[i]->arr[j]);
            }
        }
        printf("\n");
    }
    printf("================================\n");
}

// 打印集合内容
void print_set_content(SET_t* set, const char* prefix) {
    printf("%s: ", prefix);
    if(!set) {
        printf("空集合\n");
        return;
    }
    for(int i = 0; i < set->idx; i++) {
        printf("%d ", set->arr[i]);
    }
    printf("\n");
}

//测试内容
// int main() {
//     // 1. 创建时间轮
//     TimeWheel_t* tw = TimeWheel_create();
//     if (!tw) {
//         printf("创建时间轮失败\n");
//         return -1;
//     }

//     // 2. 创建9个测试集合
//     SET_t* test_sets[9];
//     for(int i = 0; i < 9; i++) {
//         test_sets[i] = (SET_t*)calloc(1, sizeof(SET_t));
//         if(!test_sets[i]) {
//             printf("创建测试集合失败\n");
//             TimeWheel_destroy(tw);
//             for(int j = 0; j < i; j++) {
//                 free(test_sets[j]);
//             }
//             return -1;
//         }
//     }

//     // 3. 初始化测试数据，设计重叠数据以测试时间轮的更新机制
//     // 第一轮 (0-2槽位)
//     set_insert(test_sets[0], 1); set_insert(test_sets[0], 2);  // [1,2]
//     set_insert(test_sets[1], 2); set_insert(test_sets[1], 3);  // [2,3] - 2重复
//     set_insert(test_sets[2], 3); set_insert(test_sets[2], 4);  // [3,4] - 3重复
    
//     // 第二轮 (0-2槽位)
//     set_insert(test_sets[3], 1); set_insert(test_sets[3], 4);  // [1,4] - 1,4重复
//     set_insert(test_sets[4], 2); set_insert(test_sets[4], 5);  // [2,5] - 2重复
//     set_insert(test_sets[5], 3); set_insert(test_sets[5], 6);  // [3,6] - 3重复
    
//     // 第三轮 (0-2槽位)
//     set_insert(test_sets[6], 4); set_insert(test_sets[6], 7);  // [4,7] - 4重复
//     set_insert(test_sets[7], 5); set_insert(test_sets[7], 8);  // [5,8] - 5重复
//     // set_insert(test_sets[8], 6); set_insert(test_sets[8], 9);  // [6,9] - 6重复

//     // 4. 执行9次更新并观察结果
//     for(int i = 0; i < 9; i++) {
//         printf("\n========== 第 %d 次更新 ==========\n", i + 1);
//         printf("当前位置: %d\n", tw->count);
        
//         // 打印要插入的新集合
//         print_set_content(test_sets[i], "插入新集合");
        
//         // 更新时间轮并获取被替换的集合
//         SET_t* replaced = TimeWheel_insert(tw, test_sets[i]);
        
//         // 打印被替换的集合
//         print_set_content(replaced, "被替换的集合");
        
//         // 打印当前时间轮的状态
//         print_wheel_state(tw);
        
//         // 打印存活状态
//         printf("元素存活状态:\n");
//         for(int j = 1; j <= 9; j++) {
//             if(tw->isalive[j] != -1) {
//                 printf("元素 %d 在轮片 %d\n", j, tw->isalive[j]);
//             }
//         }
        
//         // 释放被替换的集合
//         if(replaced) free(replaced);
        
//         printf("=====================================\n");
//     }
//     TimeWheel_destroy(tw);
//     return 0;
// }